package tool

// // **计算文件哈希**
// func ComputeFileHash(filePath string) (string, error) {
// 	file, err := os.Open(filePath)
// 	if err != nil {
// 		return "", err
// 	}
// 	defer file.Close()

// 	hasher := sha256.New()
// 	if _, err := file.WriteTo(hasher); err != nil {
// 		return "", err
// 	}

// 	return hex.EncodeToString(hasher.Sum(nil)), nil
// }

// // **ZKP 电路**
// type HashCircuit struct {
// 	InputHash frontend.Variable `gnark:",public"`
// }

// // **ZKP 约束**
// func (c *HashCircuit) Define(api frontend.API) error {
// 	// 计算哈希
// 	hash := sha2.New(api)
// 	api.AssertIsEqual(hash.Sum(), c.InputHash)
// 	return nil
// }

// // **生成 ZKP 证明**
// func GenerateProof(hash string) (groth16.Proof, groth16.ProvingKey, groth16.VerifyingKey) {
// 	// 1. 创建电路
// 	var circuit HashCircuit
// 	r1cs, err := frontend.Compile(r1cs.NewBuilder, &circuit)
// 	if err != nil {
// 		log.Fatalf("编译电路失败: %v", err)
// 	}

// 	// 2. 生成密钥
// 	pk, vk, err := groth16.Setup(r1cs)
// 	if err != nil {
// 		log.Fatalf("生成密钥失败: %v", err)
// 	}

// 	// 3. 计算哈希
// 	hashVar, _ := frontend.NewVariable(hash)

// 	// 4. 生成证明
// 	assignment := &HashCircuit{InputHash: hashVar}
// 	proof, err := groth16.Prove(r1cs, pk, assignment)
// 	if err != nil {
// 		log.Fatalf("生成 ZKP 失败: %v", err)
// 	}

// 	return proof, pk, vk
// }

// // 存储零知识证明
// func StoreZKP(client *mongo.Client, database, collection, id, hash string, proof []byte) {
// 	coll := client.Database(database).Collection(collection)

// 	doc := bson.M{
// 		"patient_id": id,
// 		"hash":       hash,
// 		"proof":      proof,
// 	}

// 	_, err := coll.InsertOne(context.TODO(), doc)
// 	if err != nil {
// 		log.Fatalf("存储 ZKP 失败: %v", err)
// 	}
// 	fmt.Println("✅ ZKP 证明存储成功！")
// }

// // 从数据库读取 ZKP 并验证
// func ValidateZKP(client *mongo.Client, database, collection, id, newHash string, vk groth16.VerifyingKey) bool {
// 	coll := client.Database(database).Collection(collection)

// 	filter := bson.M{"patient_id": id}
// 	var result bson.M
// 	err := coll.FindOne(context.TODO(), filter).Decode(&result)
// 	if err != nil {
// 		log.Fatalf("读取 ZKP 失败: %v", err)
// 	}

// 	storedHash := result["hash"].(string)
// 	proofBytes := result["proof"].([]byte)

// 	// 解析 ZKP 证明
// 	var proof groth16.Proof
// 	proof.UnmarshalBinary(proofBytes)

// 	// 执行验证
// 	isValid, err := groth16.Verify(proof, vk, []frontend.Variable{storedHash})
// 	if err != nil {
// 		log.Fatalf("ZKP 验证失败: %v", err)
// 	}

// 	if isValid {
// 		fmt.Println("✅ ZKP 证明验证通过，文件完整")
// 	} else {
// 		fmt.Println("❌ ZKP 证明验证失败，文件可能被篡改！")
// 	}
// 	return isValid
// }

// func EncryptAndStore(client *mongo.Client, params bfv.Parameters, pk *rlwe.PublicKey) {
// 	// 1. 读取文件
// 	localFile := "test.dcm"
// 	data, _ := ioutil.ReadFile(localFile)

// 	// 2. 计算哈希
// 	hash, _ := ComputeFileHash(localFile)

// 	// 3. 生成 ZKP 证明
// 	proof, _, vk := GenerateProof(hash)

// 	// 4. 存入数据库
// 	StoreZKP(client, "medicalDB", "zkp_proofs", "patient123", hash, proof.MarshalBinary())

// 	// 5. 加密文件
// 	encryptedData := EncryptFile(localFile, params, pk)
// 	StoreEncryptedData(client, "medicalDB", "encrypted_files", "patient123", encryptedData, hash)

// 	// 6. 存储验证密钥
// 	StoreVerifyingKey(vk)
// }

// func RetrieveAndDecrypt(client *mongo.Client, params bfv.Parameters, sk *rlwe.SecretKey) {
// 	// 1. 读取加密数据
// 	encryptedData, storedHash := RetrieveEncryptedData(client, "medicalDB", "encrypted_files", "patient123")

// 	// 2. 解密
// 	decryptedData := DecryptFile(encryptedData, params, sk)

// 	// 3. 保存解密文件
// 	decryptedFile := "decrypted.dcm"
// 	SaveDecryptedFile(decryptedFile, decryptedData)

// 	// 4. 计算新哈希
// 	newHash, _ := ComputeFileHash(decryptedFile)

// 	// 5. 读取 ZKP 验证密钥
// 	vk := LoadVerifyingKey()

// 	// 6. 进行 ZKP 验证
// 	if ValidateZKP(client, "medicalDB", "zkp_proofs", "patient123", newHash, vk) {
// 		fmt.Println("✅ 文件完整性验证通过！")
// 	} else {
// 		fmt.Println("❌ 文件完整性验证失败，可能被篡改")
// 	}
// }
